#include <iostream>
#include <vector>
#include <queue>
#include <utility>


class Solution1
{
    private:
    void recursion(std::vector<std::vector<int>>&islands,int curr_r,int curr_c)
    {
        // 把当前位置标记为零
        // 递归问题就是这样，当你把整体思路全理清之前，
        // 有可能你毫无头绪，但是一旦你弄懂递推关系以后，整个递归就会变成一个特别清晰的框架
        islands[curr_r][curr_c] = 0;

        // 前置判断防止越界
        int n = islands.size();
        
        // 根据if 判断调用递归
        if (curr_r+1<n&&islands[curr_r+1][curr_c])
        {
            recursion(islands,curr_r+1,curr_c);
        }
        if (curr_c+1<n&&islands[curr_r][curr_c+1])
        {
            recursion(islands,curr_r,curr_c+1);
        }
        if (curr_c-1>-1&&islands[curr_r][curr_c-1])
        {
            recursion(islands,curr_r,curr_c-1);
        }
        if (curr_r-1>-1&&islands[curr_r-1][curr_c])
        {
            recursion(islands,curr_r-1,curr_c);
        }
    }

    public:
    int solve(std::vector<std::vector<int>>&islands)
    {
        int count = 0;
        int n = islands.size();

        for (int i = 0;i < n;i++)
        {
            for (int j = 0;j < n;j++)
            {
                if (islands[i][j])
                {
                    // 如果发现有陆地的地方，就加一并且调用递归把能广度的地方全广掉
                    count++;
                    recursion(islands,i,j);
                }
            }
        }
        return count;
    }
};

class Solution2
{
    private:
    void bfs(std::vector<std::vector<int>>&islands,int cr,int cc)
    {
        // 由于递归可能会导致栈溢出，因此使用迭代的方法来进行广度优先搜索
        // 使用queue进行广度优先搜索
        int n = islands.size();
        std::queue<std::pair<int,int>>q;
        q.push(std::make_pair(cr,cc));

        while (!q.empty())
        {
            // 习惯写法适用于对子吗？？？？
            std::pair<int,int>temp = q.front();
            q.pop();
            islands[temp.first][temp.second] = 0;

            // 对接下来的周围节点
            if (temp.first+1<n&&islands[temp.first+1][temp.second])
            {
                q.push(std::make_pair(temp.first+1,temp.second));
            }
            if (temp.first-1>-1&&islands[temp.first-1][temp.second])
            {
                q.push(std::make_pair(temp.first-1,temp.second));
            }
            if (temp.second+1<n&&islands[temp.first][temp.second+1])
            {
                q.push(std::make_pair(temp.first,temp.second+1));
            }
            if (temp.second-1>-1&&islands[temp.first][temp.second-1])
            {
                q.push(std::make_pair(temp.first,temp.second-1));
            }
        }
    }

    public:
    int solve(std::vector<std::vector<int>>&islands)
    {
        // 我觉得只能使用std::pair<int,int>来进行这个工作
        int count = 0;
        int n = islands.size();

        // 如果是C语言就要创建一堆指针
        for (int i = 0;i < n;i++)
        {
            for (int j = 0;j < n;j++)
            {
                if (islands[i][j])
                {
                    count++;
                    bfs(islands,i,j);
                }
            }
        }

        return count;
    }
};

int main()
{
    int n = 0;
    std::cin>>n;

    std::vector<std::vector<int>>islands;
    for (int i = 0;i < n;i++ )
    {
        std::vector<int>temp ;
        for (int j = 0;j < n;j++)
        {
            int t = 0;
            std::cin>>t;
            temp.push_back(t);
        }
        islands.push_back(temp);
    }

    Solution2* s2 = new Solution2;
    std::cout<<s2->solve(islands)<<'\n';
    delete s2;

    return 0;
}